home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d2 / serlyz03.arc / QBSERLYZ.DOC < prev    next >
Text File  |  1989-11-13  |  44KB  |  1,058 lines
  1.  
  2.  
  3.  
  4.                                   QBSerlyze
  5.                                 Version 1.04
  6.                    Program Serializer for QuickBASIC Programs
  7.  
  8.                         Copyright InfoSoft 1988-1989
  9.  
  10.  
  11.  
  12.     1.0         Introduction
  13.  
  14.  
  15.        Serialized .EXE program files have generally been difficult to
  16.     impossible to do for programs written in QB simply because the QB
  17.     compiler lacks the ability of compile time variable definitions.  The
  18.     basic alternative was to debug or 'hack' up a master copy for each user
  19.     that registers a copy of your program or to recompile with a new
  20.     variable assignment.
  21.  
  22.        QBSerlyze provides complete and professional serial numbering
  23.     support for QB and includes extensive validity checking.  Whereas even
  24.     some commercial programs allow you to alter (change or even remove!)
  25.     the serial number display, QBSerlyze performs some rudimentary
  26.     encryption of the serial number as well as checking the validity at
  27.     runtime.  This allows you to stop the system or issue warnings when the
  28.     serial number has been altered.
  29.  
  30.        The encryption and checking are not fool-proof (very little is
  31.     these days), but is designed to be as close to that as possible with a
  32.     minimum of overhead.  The serial string is embedded and protected on
  33.     several levels:  First, the serial number is encoded, so that if the
  34.     serial number is "12345", it takes more than simply loading a byte
  35.     level editor and doing a search for "12345".  The theory here being
  36.     that if they can't find it, they can't change or remove it.  Secondly,
  37.     should a devious (yet talented) person find it, the number they
  38.     substitute for your valid number may not be a valid serial number and
  39.     your program can verify the validity at run time!  This level also
  40.     helps preclude someone from typing in an incorrect serial number (or
  41.     simply mistyping it) when serializing.  Thirdly and finally, should
  42.     they successfully patch a serialized program with another valid serial
  43.     number, the internal validity checking would identify that the serial
  44.     string has been modified since it was installed.
  45.  
  46.  
  47.        QBSerlyze support functions are extremely flexible allowing the
  48.     serial number to be installed or locked into your program in a nuber of
  49.     ways.  One method allows an 'install' sub routine to embed the serial
  50.     number into your EXE, or you can link this function into your program
  51.     so that the first time your program is run, or in response to a
  52.     /REGISTER or /INSTALL switch, your program serializes itself!
  53.  
  54.  
  55.  
  56.  
  57.                      Copyright InfoSoft 1988-1989, 1990
  58.  
  59.  
  60.  
  61.     2.0         QBSerylze Files
  62.  
  63.     QBSERIAL.EXE   - An external 10k program you can distribute with your
  64.                      program(s) to embed a serial number you assign to
  65.                      a registered user or program.  This is ideal for
  66.                      larger programs where you prefer not to link in the
  67.                      code to embed the serial number to your program since
  68.                      it is called only once.
  69.  
  70.  
  71.     QBSERLYZ.EXE   - An alternative to QBSERIAL.EXE that requires the user
  72.                      to acknowledge certain licensing terms before the
  73.                      program is serialized.
  74.  
  75.  
  76.     QBSER.OBJ      - A callable QB subroutine to embed a valid serial
  77.                      number into a EXE.  This perfoms the identical
  78.                      function of QBSERIAL.EXE except rather than an
  79.                      external program doing the serializing, your program
  80.                      can serialize itself.  Using this method requires that
  81.                      your program run under DOS 3.0 or above, however.
  82.                      Note that since the disk EXE file is serialized this
  83.                      cannot be called from inside the environment.
  84.  
  85.  
  86.     SERNO.OBJ      - These are simply assembler support files for the
  87.                      various functions.
  88.  
  89.  
  90.     QBSERGEN.EXE   - This simply generates valid serial numbers within a
  91.                      range you specify.  More on this later.
  92.  
  93.  
  94.  
  95.     3.0         Serial Number Format
  96.  
  97.         As of version 1.04, QBSerlyze supports 4, 5 or 6 digit serial
  98.     numbers.  This allows maximum flexibility, such as in supporting
  99.     different versions, product lines or batches, QBSerlyze encodes a
  100.     serial number and registration name into the EXE file, are in the
  101.     following format:
  102.  
  103.             vvv-ssss[s[s]]  <5 to 32 character Registration Name>
  104.  
  105.     vvv         - The version number you define or assign.
  106.     ssss[s[s]]  - The actual serial number from the QBSerlyze generator.
  107.                   Valid serial numbers can be in the form 4, 5 or 6 digits.
  108.     The registration name would hold the name of the license holder.
  109.  
  110.     We will refer to the complete number (vvv-ssss) or string as the Serial
  111.     String, the vvv as the Version Number and ssss as the Serial Number,
  112.     the complete string of embedded information (including the name) will
  113.     be referred to as the registration string.
  114.  
  115.  
  116.                      Copyright InfoSoft 1988-1989, 1990
  117.  
  118.  
  119.     The information embedded into the EXE file also contains a registration
  120.     string or name.  That is, the information locked into the EXE is would
  121.     be on the order of the following:
  122.  
  123.     101-12345  Bob's Lava Lamp Emporium
  124.  
  125.     The registration name string is limited to a minimum of 5 and a maximum
  126.     of 32 characters.  This name is encoded like the serial string is and
  127.     protected by a CRC algorithm so that changes can be detected at
  128.     runtime.
  129.  
  130.  
  131.  
  132.     3.1         Version Number
  133.  
  134.       The version number need not refer to an actual version of your
  135.     product (though it can), but can be anything you care to represent in 3
  136.     digits.  For example, your FooBar program might be coded as "101",
  137.     FooBar Deluxe as "201", and FooBar Deluxe Plus as "301" and so forth.
  138.     This could alternatively represent "batches".  Once you have sold so
  139.     many registrations that the number of valid 4 digit serial numbers is
  140.     exhausted, the FooBar version number could be incremented from
  141.     "101" to "102" you could then reissue all the valid 4 digit serial
  142.     numbers.  Or the version number could be meaningless - it is up to you.
  143.  
  144.        The serial numbering and checking algoroithms check the entire
  145.     'packet' of registration information: the version number, serial number
  146.     and name the program is registered under.
  147.  
  148.        While there is no validity check done on the version number (the
  149.     QBSerlyze routines have no idea of the algorithm you are using when
  150.     assigning them), at installation or when serializing, the QBSerlyze
  151.     routines will encode the version number and once serialized, any
  152.     changes or tampering with the version number, serial number or
  153.     registration name will be detected.   However, only the actual serial
  154.     number is checked at install time for validity, if the end user
  155.     embeds a nonsence version number, QBSerlyze will have no way to tell
  156.     this.
  157.  
  158.     NOTE:  While it is up to you WHAT the version number identifies, it
  159.     must be listed or passed to the installation routines or an error is
  160.     reported.
  161.  
  162.  
  163.  
  164.     3.2         Separating dash
  165.  
  166.        The separating dash is required, though for no particular reason
  167.     except maybe to make it explictly clear where the version number stops
  168.     and the serial number starts.
  169.  
  170.        The installation and some parts of the checking algorithms will
  171.     report an error or invalid serial string if there is no dash present.
  172.  
  173.  
  174.  
  175.                      Copyright InfoSoft 1988-1989, 1990
  176.  
  177.  
  178.  
  179.     3.3         Serial Number
  180.  
  181.         The serial number portion of the string is where the serial or
  182.     program control is.  QBSerlyze supports 4, 5 or 6 digit serial
  183.     numbers, that is,
  184.             VVV-SSSS
  185.             VVV-SSSSS
  186.               and
  187.             VVV-SSSSSS
  188.     are all valid serial strings, and are the ONLY valid serial number
  189.     string formats.
  190.  
  191.         Where you have total control over the version number, you have
  192.     little control over the serial number.  These are generated according
  193.     to a specific algorithm so that EVERY 4, 5 or 6 digit number is not a
  194.     valid serial number.  This allows the QBSerlyze routines to check the
  195.     validity of an alleged serial string at run-time and when being
  196.     installed.
  197.  
  198.         Four digit serial numbers range from 1000 to 9999, five range from
  199.     10000 to 99999 and 6 digit serial numbers range from 100000 to 999999.
  200.     In the four digit realm there are 296 valid serial numbers, five digit
  201.     has 5432.  The six digit realm has 5500 valid serial numbers in just
  202.     the first 100,000 numbers (100,001 to 200,000)
  203.  
  204.         Although the validation algorithm is different depending on the
  205.     number of serial digits, you should be aware that if you issue a
  206.     valid 5 digit number to someone, the install processes WILL allow them
  207.     to install a valid 4 digit one should they happen upon one, or know one
  208.     from a different product line.  The install program/sub routine have no
  209.     way of knowing which serial number format you intended.
  210.  
  211.        The chances of a five digit serial number being mistyped (by
  212.     dropping one of the characters) and that resulting 4 digit code being
  213.     valid are slim.  That is, if you issue ABCDE, the chances of ABCD or
  214.     BCDE being valid 4 digit serials are slim.   Should that person contact
  215.     you for support and you ask for the serial string, you would likely
  216.     recognize the problem or error based on the version number and the
  217.     combination.
  218.  
  219.        When embedding the registration string, all the QBSerlyze methods of
  220.     serializing, check the serial number portion to see that it fits the
  221.     serial number algorithm before encoding and embedding the registration
  222.     string, so that an invalid serial number will not be placed in the EXE
  223.     file.  Additionally, the QBSerlyze support functions will detect a
  224.     change to the registration string once serialized (at runtime).
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.                      Copyright InfoSoft 1988-1989, 1990
  235.  
  236.  
  237.  
  238.     3.4         Registration Name
  239.  
  240.       The registration name allows for 5 to 32 characters to be embedded
  241.     into the EXE file.  Like the version number, QBSerlyze has no way of
  242.     knowing if the registration name entered is valid, but once installed,
  243.     it cannot be changed without detection.
  244.  
  245.       The only way to alter this would be to re-install the entire
  246.     registration string to a pristine copy of your program.  When
  247.     serializing, the Registration Name is also encoded like all other parts
  248.     of the Registration String, and changes after that are detected at
  249.     run-time.  However, there can be no way for the QBSerlyze routines to
  250.     verify the Registration Name, eg entering Santa Claus as the
  251.     Registration Name.  Since there is now way to change the name except to
  252.     reserialize it from a pristine copy of the program such as the
  253.     distribution diskette, you can discourage such false names by
  254.     displaying the serial number.  After all, who really wants Mickey Mouse
  255.     or Santa Claus showing up on the screen as the person the program
  256.     is registered to every time the program is run?  Alternatively, if you
  257.     perform the serialization of the program according to the order
  258.     form, all this becomes academic.
  259.  
  260.  
  261.  
  262.     4.0         Generating Serial Numbers - QBSerGen
  263.  
  264.        QBSerGen is a utility program for the publisher or developer to
  265.     aid in identifying valid serial numbers in a given range and/or realm.
  266.     Since there are a fixed, finite number of valid serial numbers in
  267.     the respective realms of 4, 5 and 6 digits, QBSerGen will list those
  268.     valid ones to the output device of your choosing.  The syntax is:
  269.  
  270.     QBSerGen  <Size>  <StartNo>  <StopNo>  <S | F | P>
  271.  
  272.     SIZE     is the realm to use. Enter 4, 5 or 6 only as the size of the
  273.              serial number to generate.
  274.  
  275.     STARTNO  the first number to start with.  Since the 6 digit realm
  276.              contains so many valid numbers, you may want to generate
  277.              these a little at a time.  StartNo must have at least
  278.              SIZE number of digits in it.  That is, 999 is too low for
  279.              the 4 digit realm.
  280.  
  281.     STOPNO   the last number to test or scan as fitting the algorithm.
  282.  
  283.     OUTPUT   output can be sent to the Screen, File or Printer.  You
  284.              need only enter S, F or P in any case.  File output is
  285.              sent to QBSER4.LST, QBSER5.LST and QBSER6.LST depending on
  286.              SIZE.  Note that these files are OVERWRITTEN if they already
  287.              exist, this should be of no concern since the same serial
  288.              numbers are always generated.  As you will see later, File
  289.              output is by far, the most usefull and flexible.
  290.  
  291.  
  292.                      Copyright InfoSoft 1988-1989, 1990
  293.  
  294.  
  295.  
  296.     When QBSerGen is done, it 'stamps' the number of valid serial listed,
  297.     and the last number tested to the output device/file (screen, file or
  298.     printer).   Regardless of the output mode, pressing ANY key while
  299.     QBSerGen is working will halt the process.  When this happens the last
  300.     number tested is stamped to the output device/file.
  301.  
  302.     Note that QBSerGen only generates the serial number and has nothing to
  303.     do with the version number you may choose to prefix it with.
  304.  
  305.     Example:
  306.  
  307.     QBSerGen 5  10000  90000  File
  308.  
  309.     Lists all valid 5 digit serial numbers found between 10000 (the lowest
  310.     possible) and 90000 (90001 to 99999 are not screened) and output is
  311.     sent to QBSER5.LST in the default directory.  If your customer database
  312.     program reads or accesses the list of serial numbers, take care that
  313.     you do not overwrite file lists in use with a new one!
  314.  
  315.  
  316.  
  317.  
  318.     4.1         QBSerGen Lists and usage
  319.  
  320.         The output list from QBSerGen (in file mode) can be used in many,
  321.     many ways.  First, the format is such that LINE INPUT or INPUT can be
  322.     used to input them into your customer database program.   The
  323.     flexibility of this is incredible:
  324.  
  325.     * Your customer database program could read in the list, prefix each
  326.       serial number with the version number and dash, and print out
  327.       notes, letters or cards identifying the serial number.  Eg:
  328.  
  329.            +-------------------------------------------------+
  330.            |                                                 |
  331.            |    NOTE:  Your FooBar serial number is:         |
  332.            |                                                 |
  333.            |                   123-4567                      |
  334.            |                                                 |
  335.            |            DO NOT LOSE THIS NUMBER!             |
  336.            |     YOU WILL NEED IT FOR UPGRADES AND SUPPORT   |
  337.            |                                                 |
  338.            |    To take advantage of the features of         |
  339.            |    FooBar Deluxe, type:                         |
  340.            |                                                 |
  341.            |    FooBar /Register <your serial number>        |
  342.            |                                                 |
  343.            |    and FooBar will then be fully registered     |
  344.            |    and the Deluxe features will work.           |
  345.            +-------------------------------------------------+
  346.  
  347.        At this point, you simply enclose the note with your 'standard'
  348.        disk and let THEM do the installation.
  349.  
  350.  
  351.                      Copyright InfoSoft 1988-1989, 1990
  352.  
  353.  
  354.  
  355.     *  Alternatively, if you choose not to use the standalone serializer
  356.        and prefer to have the program serialize themselves, you could
  357.        easily have your INSTALL sub program print out such a note.
  358.  
  359.     *  An intermediary program could convert the list to a "blank" random
  360.        file where only the Serial string is filled in.  When filling an
  361.        order for your product(s), your database program does a GET from the
  362.        blank serial number file, you fill in name etc, and then the
  363.        database program could generate a note like above, but WITH the
  364.        customer name and number on it.  Be sure to delete or mark the used
  365.        blank serial number record as "issued" so that you do not issue the
  366.        same number twice!
  367.  
  368.     * If your text editor can do block moves and fills, you could edit the
  369.       list(s) to prefix the version number to each, or make product based
  370.       lists.  Prefixing "1234" with "101-" could be stored into a list of
  371.       valid FooBar serial numbers, adding "102-" and storing in another
  372.       creates a list for FooBar Deluxe.
  373.  
  374.     * Your database or other program could then scan that list to verify
  375.       the serial string given on an upgrade request or when verifying a
  376.       customer's request for phone (or other) support.  Contrast this to
  377.       looking the number up on a list - especially the 5 or 6 digit ones!
  378.  
  379.     * Alternatively, you could key in a customer name etc, get a valid
  380.       serial string and SHELL to QBSerlyze and do the serial number
  381.       embedding for them, thus precluding the chance that fake or goofy
  382.       names be embedded by the end user.
  383.  
  384.       In this case, we would read the entire list of serial numbers from
  385.       the .LST file into a fixed length string array, and then write it
  386.       back out to the same file from the first unused array element.
  387.  
  388.       Doing this, we would only generate the 6 digits ones in blocks of
  389.       5500 or so by using a range of 100,000 (100000 to 199999, then
  390.       200000 to 299999 etc) so that only a manageable number are on disk at
  391.       a time.
  392.  
  393.     These are only a few of the ways that you can use QBSerlyze to make
  394.     your life easier as the support/developer side.  The amount of time it
  395.     saves you in registering disks or programs is limited mostly by how you
  396.     incorporate QBSerGen lists into your support program(s) or database.
  397.  
  398.  
  399.  
  400.  
  401.  
  402.  
  403.  
  404.  
  405.  
  406.  
  407.  
  408.  
  409.                      Copyright InfoSoft 1988-1989, 1990
  410.  
  411.  
  412.  
  413.     5.0         QBSerlyze Stand-alone support programs
  414.  
  415.        There are 3 standalone QBSerlyze programs that support the QBSerlyze
  416.     scheme.  The first, QBSerGrn is covered above and is used to generate
  417.     valid serial numbers in a range.  The others are used to actually
  418.     serialize the program.
  419.  
  420.        As noted above, there are 2 ways to actually, physically serialize
  421.     your programs.  The first is to use QBSERIAL.EXE or QBSERLYZ.EXE, the
  422.     other is to link in QBSER.OBJ.  These all perform the same technical
  423.     function of embedding a valid serial string into your program.  The
  424.     difference is that QBSERIAL and QBSERLYZE are PROGRAMS that serialize
  425.     your program, where QBSerInstall is a called ROUTINE in QBSER.OBJ that
  426.     allows the program to serialize itself.  There are advantages and
  427.     disadvantages to each.
  428.  
  429.  
  430.  
  431.     5.1         QBSERIAL.EXE
  432.  
  433.     QBSerial is a command line driven program to embed the serial string
  434.     given on the command line into a file.  The syntax is:
  435.  
  436.     QBSerial  <prog name>  <serial string>  <Registration Name>
  437.  
  438.     QBSerial DOES check the string prior to embedding it to see that it is
  439.     valid.  As noted earlier however, it cannot know whether you intended a
  440.     4, 5 or 6 digit string be entered.  If valid, the serial string is
  441.     encoded and embedded in the file.  Note that the file to be serialized
  442.     can only be serialized ONCE, if a person mistypes something, it would
  443.     have to be re-serialized from a pristine copy.
  444.  
  445.     The advantages to QBSerial are that the code to do the embedding is
  446.     kept external from your program.  Since it would only be called once,
  447.     it is kind of a waste of code and data space to be in the EXE file
  448.     forever (the inline, callable version temporarily uses a little over 2k
  449.     of string space but frees it up before completion).  Within in the
  450.     QBSerial version 1.xx range, I promise NOT to change the serial
  451.     encoding algorithm so you would need to re-distribute QBSERIAL.EXE only
  452.     once per customer (until version 2.0 is released).
  453.  
  454.     The disadvantages are that QBSERIAL.EXE could get lost or deleted and
  455.     the user would then be unable to re-register backup or original copies,
  456.     and finally, QBSerial heralds the InfoSoft copyright which may or may
  457.     not bother you or confuse your end user.
  458.  
  459.     Note Well: Given the drawbacks of people entering nonsence as the
  460.     version string or registration name, and the (however slim) possibility
  461.     of a mistyped-yet-valid serial string, the only way to BE SURE that the
  462.     correct information is entered is for YOU to enter it into your product
  463.     before shipping.  The drawback to this the immense amount of valuable
  464.     time this can consume.  The compromise is to modify (or write) your
  465.     customer database program to 'hook' into the serial list you are using
  466.     and SHELL to QBSERIAL.EXE to do the embedding.
  467.  
  468.                      Copyright InfoSoft 1988-1989, 1990
  469.  
  470.  
  471.     5.2         QBSERLYZ.EXE
  472.  
  473.        QBSerlyz.EXE has the same syntax and performs the same identical
  474.     function to QBSerial.EXE except that it is a Verbose or Terse type
  475.     approach.  Before the subject program is actually serialized, the user
  476.     is asked two questions:
  477.  
  478.     "Have you read and do you understand the terms of the
  479.      licensing agreement for <prog name> (YES/NO)? "
  480.  
  481.     "Do you agree to abide by, and be bound by those terms (YES/NO) ?"
  482.  
  483.     The person performing the installation must answer "YES" or "yes" to
  484.     both questions ("Y" and "y" do not cut it!), or the serializing aborts.
  485.  
  486.         This is provided mostly as a service to fully commercial developers
  487.     who may choose to require such terms be agreed to before the program be
  488.     registered.  If you do not supply a written licensing agreement with
  489.     each and every disk, you should not use this method of serializing.
  490.  
  491.         The advantage of this serialization method is clearly that you get
  492.     explicit confirmation of the user's intent to abide by your terms
  493.     before it is registered and/or registered features are enabled.
  494.  
  495.        The disadvantages of the method QBSerlyze are the same as QBSerial,
  496.     although for a reasonable sum, I will customize QBSerlyz for specific
  497.     licensing agreement messages and alter the InfoSoft copyright herald.
  498.     Again, this will be mostly of interest to fully commercial developers
  499.     (or very, very serious shareware ones!).
  500.  
  501.  
  502.  
  503.     5.3         QBSerInstall
  504.  
  505.       The last method of embedding the serial string is to allow the
  506.     program to do it to itself.  By calling QBSerInstall, FOOBAR.EXE can
  507.     serialize itself.  This self installing routine is in the object module
  508.     QBSER.OBJ.   The syntax is:
  509.  
  510.     errc = QBSerInstall%(serial$, RegName$)
  511.  
  512.     Your program will have to fetch the serial$ from the command line or
  513.     get it as input from the user to pass it to the routine.  The function
  514.     returns a variety of error codes:
  515.  
  516.      0 = Installed ok
  517.     -2 = Invalid serial number
  518.     -4 = QB.EXE is loaded (cannot install into a EXE from the environment!)
  519.     -5 = Cannot serialize - Too many support copies appear linked
  520.          (SERNO.OBJ)
  521.     -6 = Cannot serialize - Cannot find support module, or already
  522.          serialized.
  523.  
  524.  
  525.  
  526.  
  527.                      Copyright InfoSoft 1988-1989, 1990
  528.  
  529.  
  530.  
  531.       The advantages of this method are that there is no need of an
  532.     external serializer program, but on the other hand, the code used to
  533.     serialize itself is used only once, but remains in the program forever.
  534.     This internal method is slightly slower than either external method,
  535.     and is considerably bulkier since additional checking must be performed
  536.     to ensure that the process aborts if QB.EXE is loaded.
  537.  
  538.       Note that this method requires DOS 3.x+ at run time.  QBSERIAL.EXE
  539.     and QBSERLYZ.EXE do also, but that has no bearing on what DOS version
  540.     your program runs under.
  541.  
  542.       Immediately after calling QBSerInstall, remember that the returns
  543.     from the QBSerlyze support functions (see below) will not be valid
  544.     until NEXT time the program starts.  This is because when a program
  545.     loads into memory a COPY of the disk form is loaded - after calling
  546.     QBSerInstall, the disk form is indeed, serialized, but not the one in
  547.     memory!  If the return from QBSerInstall is ok (0), then you can simply
  548.     terminate the program or force a variable TRUE.  Eg:
  549.     IF INSTR(COMMAND$, "/INSTALL") THEN     ' requesting install
  550.        GOSUB GetRegName                     ' perform serial name I/O
  551.        errc = QBSerInstall(Serial$, RegName$)
  552.        IF errc = 0 THEN
  553.            Registered = 1
  554.  
  555.            ' or to force a restart:
  556.          ' PRINT "Serialization Complete.  Restart program."
  557.          ' SYSTEM
  558.  
  559.            ' or if you have GLIB:
  560.          ' errc = PrgName(myname$, los)         ' get EXE program name
  561.          ' myname$ = LTRIM$(RTRIM$(myname$))    ' trim it
  562.          ' RUN myname$                          ' run it allowing for paths
  563.        ELSE
  564.  
  565.            GOSUB PrintCorrectSyntax
  566.            SYSTEM
  567.  
  568.        END IF
  569.     END IF
  570.  
  571.  
  572.       A further warning is that you must decide at compile time whether to
  573.     use the external serializing method (ala' QBSerial or QBSerlyz) or the
  574.     internal one (QBSerInst).  You cannot link in QBSER.OBJ and still use
  575.     either external method for serializing as the external programs will be
  576.     confused as to where to store the serial number.  Additional LINK time
  577.     instructions are provided in Section 7.0.
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586.                      Copyright InfoSoft 1988-1989, 1990
  587.  
  588.  
  589.  
  590.     6.          QBSerlyze Runtime Functions
  591.  
  592.        Once your program is properly serialized, it can begin to use the
  593.     returns from the QBSerlyze support functions at runtime.  A series of
  594.     functions are provided to query the QBSerlyze status:
  595.  
  596.        SerialInst%
  597.        SerialValid%
  598.        SerialGet%
  599.        SerNameGet%
  600.  
  601.  
  602.     Name: SerialGet             Type: FUNCTION
  603.         Syntax:  errc = SerialGet%(serial$, size)
  604.  
  605.         This polls the QBSerlyze system and returns the complete serial
  606.     string embedded and the size code.  All the runtime support systems are
  607.     written in assembler, so you must initialize serial$ to
  608.     SPACE$(4 + SIZE), where SIZE is the size of the serial number (4, 5 or
  609.     6 for a total of 8, 9 or 10 spaces) - the additional 4 is to allow for
  610.     the 3 version number characters and the dash.
  611.          Upon return, this will fill serial$ with the entire serial
  612.     string (serial number AND version number), size% will return the number
  613.     of serial digits embedded (ie 4, 5 or 6 - NOT including the 4
  614.     characters in the version number and dash!).  This allows your program
  615.     to verify the SIZE code at runtime also.
  616.  
  617.         Note that in the interest of speed, the serial number is not
  618.     validated with this function.  In fact, the only need for this routine
  619.     is if you wanted to display the serial string upon start up or in an
  620.     error message such as
  621.     PRINT  "Serial number "; serial$; "; is inavlid!"
  622.     or in reponse to a user keypress request to display the serial number
  623.     for verification.  That is, there is no need to actually get or display
  624.     the serial number in order to use and act on the QBSerlyze system.
  625.  
  626.          Error code returns possible are:
  627.      0 = serial string appears OK
  628.     -2 = program not serialized
  629.     -3 = serial$ too short
  630.     -7 = invalid size (ie not 4, 5 or 6)
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638.  
  639.  
  640.  
  641.  
  642.  
  643.                      Copyright InfoSoft 1988-1989, 1990
  644.  
  645.  
  646.  
  647.     Name: SerNameGet            Type: FUNCTION
  648.         Syntax:  errc = SerNameGet(RegName$)
  649.  
  650.        This complements the SerialGet routine by fetching and decrypting
  651.     the name to whom the program is registered to.  The string variable
  652.     RegName$ must be initialized to 32 spaces to allow for the maximum
  653.     possible length to be fetched.  As with the other QBSerlyze support
  654.     routines, this only decodes the string if the program is serialized, it
  655.     does not check whether the string has been altered.  This function is
  656.     only performed by SerialValid.
  657.  
  658.     Possible errc returns:
  659.     -2 = Program not serialized (RegName$ not filled).
  660.     -3 = RegName$ too short or null.  Only as much of name as will fit is
  661.          returned.
  662.  
  663.  
  664.  
  665.     Name: SerialInst            Type: FUNCTION
  666.         Syntax:  errc = SerialInst%
  667.  
  668.       This polls the QBSerlyze system and returns a code indicating whether
  669.     a serial number is embedded or not.  If not, the return from SerGet can
  670.     be considered invalid and/or garbage.  This too, does no validity
  671.     checking only installation checking.
  672.  
  673.     Return codes:
  674.      0 = Installed
  675.     -2 = Not Installed
  676.  
  677.  
  678.  
  679.     Name: SerialValid           Type: FUNCTION
  680.         Syntax:  errc = SerialValid%
  681.  
  682.         This is the function onto which you can hang many program hooks.
  683.     It returns a code indicating if the embedded serial number is valid
  684.     and/or unaltered.  This checks the version number, serial number and
  685.     registration name to see if they have been altered since installation.
  686.  
  687.     Using this function allows you to determine if a call to SerialGet is
  688.     worthwhile.  This function is not inherent to SerialGet and SerialInst
  689.     to keep the number of times that the decrypting and validation
  690.     testing code to a minimum thereby making the whole process harder to
  691.     'crack'.
  692.  
  693.     Return Codes:
  694.      0 = Serial number appears valid and unaltered
  695.     -1 = Serial number NOT valid
  696.     -2 = Serial number not installed
  697.     -8 = Serial number appears altered
  698.  
  699.  
  700.  
  701.  
  702.                      Copyright InfoSoft 1988-1989, 1990
  703.  
  704.  
  705.     7.          Compile and LINK Time instructions
  706.  
  707.       There are a few items to be considered at LINK time, the first of
  708.     which is what should be LINKed into your program.  All the QBSerlyze
  709.     functions are contained in SERNO.OBJ, the main support module.  While
  710.     developing your application in the QB environment, you will need to
  711.     ignore most returns from the QBSerlyze functions.  The reason is
  712.     obviously that since QBSerlyze works on a disk EXE file, a program
  713.     loaded into QB cannot be serialized.
  714.  
  715.  
  716.     7.1     Developing a program that will be QBSerlyz-ed
  717.  
  718.         You are urged to develop your program to completion without regard
  719.     for the QBSerlyze functions and code them last.  Obviously these can
  720.     only be tested in serialized, EXE form.
  721.  
  722.       If it is your intention to only enable certain features when the
  723.     program is registered and serialized, use a dummy variable during
  724.     development.  Ex:
  725.  
  726.     ' IF SerialValid <> 0 THEN
  727.     '     Registered = 0
  728.     ' ELSE
  729.     '     Registered = 1
  730.     ' END IF
  731.  
  732.     Registered = 1
  733.  
  734.     During development or while working inside the QB editor, REM out the
  735.     actual calls to the QBSerlyze function, and force the REGISTERED
  736.     variable to either TRUE (non zero) or FALSE (zero) to test your
  737.     programs reaction to either condition.  Prior to the final compile,
  738.     reverse the above example by un-REMARKing the calls to QBSerlyze and
  739.     then REM out or remove the hard coded setting of the REGISTERED
  740.     variable.
  741.  
  742.  
  743.     7.2     Choose the Serialization method
  744.  
  745.        You must also decide if you wish to serialize the end application
  746.     internally (via a call to QBSerInstall) or whether you will be using
  747.     either of the 2 external/stand alone serializers.  Note that these 2
  748.     methods are mutually exclusive, by linking in the QBSerInstall routine,
  749.     the external serializers are confused as to where the serial number
  750.     should be placed and therefore abort doing nothing.
  751.  
  752.        At LINK time, SERNO.OBJ must be linked in for the basic QBSerlyze
  753.     assembler function support.  If you are choosing to have your program
  754.     serialize itself at runtime, you must also link in QBSER.OBJ, QBL.OBJ
  755.     and PRGNAME.OBJ.  The latter 2 are standard GLIB functions provided
  756.     with QBSerlyze and should be completely interchangeable with the
  757.     object modules of the same name from GLIB 1.6 or GLIB 1.7.  All 4
  758.     critical object modules (the three mentioned as well as SERNO.OBJ)
  759.     can also be found in QBSERLYZ.LIB).
  760.  
  761.                      Copyright InfoSoft 1988-1989, 1990
  762.  
  763.  
  764.     7.3     LINKing with /EXEPACK
  765.  
  766.        There are 2 other LINK time considerations.  First, is the use of
  767.     the /EXE switch which CANNOT be used prior to the program being
  768.     serialized.  Attempting to do so can result in "Packed File Corrupt"
  769.     error message at run time.  If you are not familiar with what '/exe'
  770.     does, it 'packs' or slightly reduces the size of the resulting EXE file
  771.     by removing extraneous NULLS from the EXE header.  The EXE file must be
  772.     serialized first, which inherently precludes the program from being
  773.     re-LINKed.  If you have BASCOM 6, MSC 'C', or MASM 5.x, you can use
  774.     EXEPACK from any of these to perform the same identical function after
  775.     the program has been serialized.  If you do not have access to any of
  776.     these, you might look for a Shareware/Freeware type program that
  777.     performs the same function, but we are not aware of any such
  778.     programmer's utility, and failing that, the EXEPACK function will have
  779.     to be omitted.
  780.  
  781.  
  782.     7.4     Using QBSerlyze with BCLock
  783.  
  784.        The other consideration is that QBSerlyze poses a conflict with our
  785.     BClock program.  (BCLock provides virus and tampering protection in
  786.     compiled EXE programs).  The very last thing that must be done is that
  787.     the program BCLOCKER is run on the EXE file to be BCLocked.  This
  788.     naturally precludes the use of the internal serializing method since
  789.     that would mean that the serialization would occur after you have
  790.     BCLocked the program.
  791.  
  792.        This also means that should you want to employ both QBSerlyze
  793.     and BCLocker on the same program, it would naturally have to be
  794.     BCLOCKED by you since BCLOCKER.EXE cannot be distibuted.  Given this,
  795.     you would also have to do the actual serialization prior to shipping
  796.     the disk(s).  This is not near the inconvenience that it sounds: using
  797.     the disk output from QBSerGen.EXE, you could edit in the names of users
  798.     from the order forms, and write a small program that reads in the next
  799.     name/serial number string, SHELLS (or modifies a BAT file you are in)
  800.     to serialize the program, then EXEPACKs it, then BCLOCKS it and makes
  801.     an entry in your customer database with that information.  The only
  802.     remaining shortfall of using both BCLOCK and QBSerlyze is the explicit
  803.     consent one garners from the agreement prompts in QBSerlyz.EXE.
  804.  
  805.  
  806.  
  807.  
  808.  
  809.  
  810.  
  811.  
  812.  
  813.  
  814.  
  815.  
  816.  
  817.  
  818.  
  819.                      Copyright InfoSoft 1988-1989, 1990
  820.  
  821.  
  822.  
  823.     7.5     Compile/Link sequence
  824.  
  825.        To be sure, the following shows how one might compile and link a
  826.     program (FOOBAR.BAS) using the above information:
  827.  
  828.  
  829.     A.   LINK with the intent of using EXTERNAL serializers only
  830.  
  831.     BC FooBar /o /s;            ' of course you may require other switches
  832.  
  833.     LINK FooBar+FooSubs+SerNo   ' you may have other modules to link in...
  834.                                 ' but DO NOT use the /EXE switch
  835.  
  836.     You are now ready to distribute program ready for serialization.
  837.  
  838.     The program may not be EXEPACKed until after it is serialized, and part
  839.     of your distribution to registered users must include either
  840.     QBSERIAL.EXE or QBSERLYZ.EXE to perform the actual serialization.
  841.  
  842.  
  843.  
  844.     B.   LINK with for EXTERNAL serializers and using BCLOCK
  845.  
  846.     BC FooBar /o /s;            ' of course you may require other swicthes
  847.  
  848.     LINK FooBar+FooSubs+SerNo   ' you may have other modules to link in...
  849.                                 ' but DO NOT use the /EXE switch
  850.  
  851.     QBSERIAL FooBar  <SerNo>  <RegName>
  852.                                 ' serialize the program with a valid serial
  853.                                 ' string and the correct user name
  854.  
  855.                                 ' optionally run EXEPACK on the file AFTER
  856.                                 ' it has been serialized
  857.     EXEPACK foobar.exe foobarr.exe
  858.     DEL foobar.exe              ' delete unpacked file
  859.     ren foobarr.exe foobar.exe  ' swap the name back
  860.  
  861.     BCLOCKER foobar.exe         ' optionally BCLock the file
  862.  
  863.     You are now ready to distibute a fully serialized and BCLocked program!
  864.  
  865.     Note that all of this could be performed via a program you whip up to
  866.     shell to BCLOCKER and EXEPACK, or in a batch file.
  867.  
  868.  
  869.  
  870.  
  871.  
  872.  
  873.  
  874.  
  875.  
  876.  
  877.                      Copyright InfoSoft 1988-1989, 1990
  878.  
  879.  
  880.  
  881.     C.   LINK with the intent of using INTERNAL serializers
  882.  
  883.     BC FooBar /o /s;            ' of course, you may require other swicthes
  884.  
  885.     LINK FooBar+FooSubs+SERNO+QBSERI
  886.                                 ' link in SERNO support and the internal
  887.                                 ' serialing function QBSerInstall.
  888.                                 ' You may have other modules to link in,
  889.                                 ' but DO NOT use the /EXE switch
  890.  
  891.     You are now ready to distibute your program!
  892.  
  893.     The program may not be BCLocked using the internal serializing method
  894.     since you may NOT distibute BCLOCKER.EXE.  The program may however, be
  895.     EXEPACKed by the end user AFTER they install or serialize the
  896.     application if they have access to EXEPACK.
  897.  
  898.     You are now ready to distibute program ready for serialization via a
  899.     the application itself.
  900.  
  901.  
  902.  
  903.  
  904.  
  905.  
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.  
  932.  
  933.  
  934.  
  935.  
  936.  
  937.  
  938.                      Copyright InfoSoft 1988-1989, 1990
  939.  
  940.  
  941.     8.0                 Advanced uses for QBSerlyze
  942.  
  943.        Note that the return from SerialValid allows you to program in
  944.     'suppressed features' without actually using the serial numbering
  945.     system or alerting the user to such.  By distributing a version of your
  946.     program with no serial number installed, you can act on the -2 return
  947.     from SerialInst% and/or SerialValid% to not execute whatever enhanced
  948.     features you provide with the registered version WITHOUT having to
  949.     maintain 2 copies of the program.
  950.  
  951.        While this can be done with a variable or constant set or cleared
  952.     (eg: CONST REGISTERED = 0), it takes much more for a person to scope
  953.     out the process used to determnine registered or non-registered status
  954.     when you use QBSerlyze.
  955.  
  956.  
  957.        Additionally, even Shareware/FreeWare type products can use
  958.     QBSerlyze as a tracking number.  If you spend hours calling various
  959.     bulletin boards to upload your products, by serializing them (as well
  960.     as the ones sent to User Groups and so forth), if your registration
  961.     form asks that they list the serial number from the copy they have, you
  962.     can begin to track which distribution outlets actually yield a return.
  963.     If a registration using the West Logoslobovia User Group/BBS serial
  964.     number has never come in, maybe the club officers are hogging the
  965.     samples (we do that, ya' know), or maybe it is just not worth the money
  966.     to mail or phone to send or upload upgrades to them every few months.
  967.  
  968.  
  969.        In the corporate environment, serializing programs used internally
  970.     to individual employees can help can dissuade pilfering (provided that
  971.     there is a use for the program outside the workplace).  If copies of
  972.     it start showing up on local bulletin boards, you might want to get it
  973.     and identify the serial number.  The fact that the program is
  974.     serialized need not even be known to the employees - perhaps it is
  975.     displayed in response to key combination known only to a few.  Of
  976.     course, if they know the programs are serialized that can help dissuade
  977.     the unwanted distribution itself.
  978.  
  979.  
  980.        There are a number of tracking, identification, verification and
  981.     developers support aides that QBSerlyze makes availble to you.
  982.     Hopefully, these few we've listed will trigger others that you can
  983.     imagine.  It is important to remember that QBSerlyze is not copy
  984.     protection, more like copy identification.  We also do not mean to
  985.     imply that the algorithm used here is fool proof - it is not.  The
  986.     encoding and validity checking do offer more than a modicum of security
  987.     on the serial string: it is not easy to find and it the checking
  988.     algorithm is internal so it is not easy to decipher what is valid and
  989.     what is not - except maybe to other developer-users of QBSerlyze.
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.                      Copyright InfoSoft 1988-1989, 1990
  997.  
  998.  
  999.  
  1000.     9.        License and distribution
  1001.  
  1002.       Because some portions of QBSerlyze, by design, are meant to be
  1003.     redistrubuted by you, we will list limitations by file:
  1004.  
  1005.     QBSERIAL.EXE and QBSERLYZ.EXE
  1006.     You may redistribute this EXE, but only with programs you design or
  1007.     develop AND are legally allowed to distribute AND that program must
  1008.     make use the QBSerial serial numbering system.  That is, at least one
  1009.     accompanying EXE file must be linked with SERNO.OBJ and make calls to
  1010.     the assembler support routines.
  1011.  
  1012.  
  1013.     SERNO.OBJ, and QBSER.OBJ
  1014.     These may only be redistributed by you to the end user in LINKED form
  1015.     as part of an .EXE application program that utilizes the QBSerlyze
  1016.     system/routines AND of which  you are the legal developer, author,
  1017.     and/or publisher.  These may not under any circumstances be distributed
  1018.     or passed along separately or in OBJECT module or OBJECT LIBRARY form.
  1019.     No portions of QBSerlyz 1.4 may be distributed or passed along in OBJ
  1020.     form.
  1021.  
  1022.  
  1023.     QBSERGEN.EXE
  1024.     This is registered to a single user or developer for the purpose of
  1025.     managing the QBSerial System.  QBSERGEN.EXE and it's output may not
  1026.     be passed along or distributed except by InfoSoft and/or it's agents.
  1027.  
  1028.  
  1029.  
  1030.  
  1031.  
  1032.     The results of any use, abuse or misuse of the QBSerlyze programs,
  1033.     system and/or subroutines are solely the responsibility of those
  1034.     programmers electing to include, implement and/or utilize QBSerlyze in
  1035.     their application program.  IN NO EVENT WILL INFOSOFT BE LIABLE
  1036.     FOR ANY DAMAGES, INCLUDING ANY LOST PROFITS, LOST SAVINGS, OR OTHER
  1037.     INCIDENTAL OR CONSEQUENTIAL DAMAGES RESULTING FROM THE USE, OR
  1038.     INABILITY TO USE THIS SOFTWARE AND DOCUMENTAION.   IN ANY CASE, OUR
  1039.     MAXIMUM LIABILITY SHALL BE LIMITED TO REFUND THE INFOSOFT LIST PRICE OR
  1040.     THE PRICE YOU PAID FOR THE SOFTWARE, WHICHEVER IS LESS.
  1041.  
  1042.     The use of QBSerlyze routines AND/or system explicitly implies your
  1043.     acceptance of, and intent to abide by these terms.
  1044.  
  1045.  
  1046.  
  1047.     10.  Acknowlegments
  1048.  
  1049.     QBSerlyze was written and developed by InfoSoft.
  1050.     BCLock and BCLOCKer are copyright InfoSoft
  1051.     QBSERYLZE is copyright InfoSoft
  1052.     GLIB 1.6 and GLIB 1.7 are copyrights of InfoSoft
  1053.     QB, QuickBASIC, EXEPACK and MASM are copyrights of Microsoft Corp.
  1054.  
  1055.  
  1056.                      Copyright InfoSoft 1988-1989, 1990
  1057.  
  1058.